package com.company.zhishidian;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
 * inputStream 字节输入流， 读单个字节
 * OutputStream 字节输出流，写单个字节
 * Reader 字符输入流  ， 读两个字节（一个字符）（char）
 * Writer 字符输出流  ， 写两个字节（一个字符）
 * 基本流
 * 过滤流（高级流） 可以封装基本流，在特殊场合使用
 * 流：是一种字符序列，流是会阻塞的
 */
public class Liu {
    public static void main(String[] args) {
        System.out.println("111"); // 标准打印流 输出流
        Scanner in = new Scanner(System.in);  // 标准输入流
        // 输入：键盘和鼠标  麦克风 扫描仪 摄像头 写字板
        // 输出：显示器  扬声器  耳机  打印机
        // 网络依赖IO流
    }
}
/* 读取文件 */
class TestInputStream1{
    public static void main(String[] args) {
        // 文件字节输入流，拟机中（内存）
        // 1.7 以前必须把流设到外面，然后在finally里面close
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("pkg/src.txt");
            // 读取一个字节
//            int b = fis.read();
            // 一次读取1024个字节
//            byte[] b = new byte[1024];
//            fis.read(b);
            // 去掉skip参数减一个的字节数开始获取
//            fis.skip(0);
//            System.out.println((char)fis.read());

            byte[] b = new byte[8];
            int len;
            StringBuilder sb = new StringBuilder();
            // 读取的过程就是一个个覆盖前一个的过程
            // 读取文件中所有字节去掉重复字节
            // [000...111] [111...222] 最后 [333...222] 取前三位
            while ((len=fis.read(b))!=-1){
                sb.append(new String(b,0,len));
            }
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
class TestInputStream2{
    public static void main(String[] args) {
        // 1.7 之后关闭流 可以 这么写
        // try-with-resource  小括号里面放能被关闭的资源(实现了closable接口)，一旦执行完代码，会自动调用close方法
        try(FileInputStream fis = new FileInputStream("pkg/src.txt")){
            byte[] b = new byte[8];
            int len;
            StringBuilder sb = new StringBuilder();
            while ((len=fis.read(b))!=-1){
                sb.append(new String(b,0,len));
            }
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
/* 写文件 */
class TestOutputStream{
    public static void main(String[] args) {
        try(FileOutputStream fos = new FileOutputStream("pkg/dest.txt")){
            // 第一次新建文件，每次往里添加内容，如果没有内容则写一个空
            String s = "abcdefg";
            fos.write(s.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
/* 文本文件 */
class TestReader{
    public static void main(String[] args) {
        try(FileReader fie = new FileReader("pkg/src.txt");){
            char[] carr = new char[10];
            int len;
            StringBuilder str = new StringBuilder();
            while ((len=fie.read(carr))!=-1){
                str.append(carr,0,len);
            }
            System.out.println(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class TestWriter{
    public static void main(String[] args) {
        try(FileWriter fie = new FileWriter("pkg/dest.txt");){
            fie.write(",jgsmdefh");
            fie.flush();  // 刷新缓冲区

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
/* 高级输入流，性能有所提高，搞了一个缓冲区 */
class TestBufferedInputStream{
    public static void main(String[] args) {
        try(BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("pkg/src.txt")
        )){
            byte[] b = new byte[8];
            int len;
            StringBuilder sb = new StringBuilder();
            while ((len=bis.read(b))!=-1){
                sb.append(new String(b,0,len));
            }
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class TestBufferedOutputStream{
    public static void main(String[] args) {
        try(BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("pkg/src.txt",true)  // 是否启用append模式，默认Flase，启用设置为true
        )){
           bos.write("wwwwwwssss".getBytes());
           bos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class TestBufferedReader{
    public static void main(String[] args) {
        try(BufferedReader buf = new BufferedReader(new FileReader("pkg/src.txt"))){
            String s;
            StringBuilder sb = new StringBuilder();
            while ((s=buf.readLine())!=null){
                sb.append(s+'\n');
        }
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
class TestBufferedWriter{
    public static void main(String[] args) {
        try(BufferedWriter buf = new BufferedWriter(new FileWriter("pkg/dest.txt"))){
                buf.write("qeesdfsd");
                buf.newLine();
                buf.write("qeesdfsd");
                buf.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
/* 转换流 */
class TestInputStreamReader{
    public static void main(String[] args) throws IOException {
        FileInputStream fs = new FileInputStream("pkg/src.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(fs));
        br.readLine();
        BufferedWriter Readbw = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream("dest.txt")
        ));
        Readbw.write("aaa");

    }
}

class TestTuPian{
    public static void main(String[] args) {
        coppy("/Users/wangmiao/Downloads/timg.jpeg","timg.jpeg");
    }
    public static void coppy(String yuantu,String xiantu){
        try(FileInputStream fis = new FileInputStream(yuantu);
            FileOutputStream fos = new FileOutputStream(xiantu)){
            byte[] b = new byte[1024];
            int len;
            while ((len=fis.read(b))!=-1){
                fos.write(b,0,len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/*
    代表文件和文件夹（路径）
 */
class TestFile{
    public static void main(String[] args) {
        File file = new File("pkg/src.txt");
        // 判断文件是否是文件/文件夹
        // 文件
        System.out.println(     file.isFile()    );
        // 文件夹
        System.out.println(     file.isDirectory()  );
        // 获得文件名
        System.out.println(     file.getName()      );
        // 获得文件的绝对路径
        System.out.println(     file.getAbsolutePath()      );
        // 删除文件,(非放进回收站)
//        file.delete();
        // 创建文件夹
//        file.mkdir();
        // 可以创建嵌套文件夹
        System.out.println(      file.mkdirs()          );
        try {
            // 创建一个空白文件
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 不常见
        // 判断该文件/文件夹是否存在
        file.exists();
        // 获得文件的长度（字节）
        file.length();
        // 获得当前文件夹下的所有 直接 子文件 和 文件夹
        File[] subFiles = file.listFiles();
        for (File sub:
             subFiles) {
            System.out.println(sub.getName());
        }
    }
}

// 显示当前文件夹下的所有文件,递归实现，分级显示 (包括子文件)
class Files{
    public static void main(String[] args) {
        File file = new File("//Users//wangmiao//BY_student//ddd");
        print(file,0);
    }

    public static void print(File file,int level){
        // 设定层级
        for (int i= 0; i < level; i ++) {
            System.out.print(" ");
        }
        // 判断文件还是文件夹
        if(file.isFile()){
            System.out.print("-");
        }else {
            System.out.print("⬛");
        }
        // 取出进来的名字
        System.out.println(file.getName());
        // 判断是文件夹就再次进入循环
        if(file.isDirectory()){
            level++;
            File[]  subFiles = file.listFiles();  // 得到所有子文件
            for (File subFile:subFiles) {
                // 不在管文件文件夹都调用函数
                print(subFile,level);
            }
        }
    }
}
